/*
 *http://www.apache.org/licenses/LICENSE-2.0
 *Copyright (c) 2021 fullset
 *@ClassName StringUtil
 *@date 2021/6/28 19:20
 *@author: pangps
 *@Description TODO
 */
package com.fs.core.util;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Arrays;
import java.util.List;
import java.util.StringJoiner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtil {

    /**
     * 如果字符串为空则返回true
     * 判断某字符串是否为空，为空的标准是str==null或str.length()==0
     * @param cs
     * @return
     */
    public static boolean isEmpty(final CharSequence cs) {
        return cs == null || cs.length() == 0;
    }

    /**
     * 如果字符串不为空则返回true
     * @param cs
     * @return
     */
    public static boolean isNotEmpty(final CharSequence cs) {
        return !isEmpty(cs);
    }

    /**
     * 全角字符变半角字符
     *
     * @param str
     * @return
     */
    public static String full2Half(String str) {
        if (str == null || "".equals(str))
            return "";
        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c >= 65281 && c < 65373)
                sb.append((char) (c - 65248));
            else
                sb.append(str.charAt(i));
        }
        return sb.toString();
    }

    /**
     * 半角字符变全角字符
     *
     * @param str
     * @return
     */
    public static String half2Full(String str) {
        char[] cha = str.toCharArray();
        for (int i = 0; i < cha.length; i++) {
            if (cha[i] == 32) {
                cha[i] = (char) 12288;
            } else if (cha[i] < 127) {
                cha[i] = (char) (cha[i] + 65248);
            }
        }
        return new String(cha);
    }

    /**
     * 判断某个字符串是否存在于数组中
     *
     * @param stringArray
     *            原数组
     * @param targetValue
     *            查找的字符串
     * @return 是否找到
     */
    public static boolean useLoop(String[] stringArray, String targetValue) {
        for (String s : stringArray) {
            if (s.equals(targetValue))
                return true;
        }
        return false;
    }

    /**
     * 正则表达式匹配连续多个空格或tab空格
     *
     * @param str
     * @return
     */
    public static String formatBlankOrTab(String str) {
        Pattern p = Pattern.compile("\\s{2,}|\t");
        Matcher m = p.matcher(str);
        String strNoBlank = m.replaceAll(" ");
        return strNoBlank;
    }

    /**
     * 获取小括号内容，不包含括号
     * @param str
     * @return
     */
    public static String formatParen(String str){
        Pattern p = Pattern.compile("(?<=\\()(.+?)(?=\\))");
        Matcher matcher = p.matcher(str);
        while(matcher.find()){
            str = matcher.group(0);
        }
        return str;
    }

    /**
     * 判断是否为整数
     * @param str 传入的字符串
     * @return 是整数返回true,否则返回false
     */
    public static boolean isInteger(String str) {
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
    }

    /**
     * 判断字符串是否是数字
     * @param target
     * @return
     */
    public static boolean isNumeric(String target){
        if(target != null && target.matches("[-+]?[0-9]+\\.?[0-9]*")){
            return true;
        }
        return false;
    }

    /**
     *  判断是否字母，忽略大小写
     * @param target
     * @return
     */
    public static boolean isLetter(String target){
        if(target.matches(".*[a-zA-z].*")){
            return true;
        }
        return false;
    }

    /**
     * 如果小数点后都是0，则去掉小数点及后面的0，去掉数字之前的0
     * @param s
     * @return
     */
    public static String subZeroAndDot(String s){
        if(null != s && s.indexOf(".") > 0){
            s = s.replaceAll("0+?$", "");//去掉多余的0
            s = s.replaceAll("[.]$", "");//如最后一位是.则去掉
        }
        if(null != s && s.startsWith("0") && !"0".startsWith(s) && !s.startsWith("0.")){
            s = s.replaceAll("^(0+)", "");//去掉数字之前的0
        }
        return s;
    }

    /**
     * 判断字符串小数点后的位数
     * @param s
     * @return
     */
    public static int getZeroAndDotCount(String s){
        if(null != s && s.indexOf(".") > -1){
            return s.length() - s.indexOf(".") -1;
        }
        return 0;
    }

    /**
     * 默认以逗号分割字符串
     * @param str
     * @param delim
     * @return
     */
    public static String [] splitCharToArray(String str, String delim){
        if(null == str){
            return null;
        }
        if(isNotEmpty(delim)){
            return str.split(delim);
        }
        return str.split(",");
    }

    /**
     * 字符串分割成集合
     * @param str 字符串
     * @param delim 分割参数
     * @return
     */
    public static List<String> splitCharToList(String str, String delim){
        if(null == str){
            return null;
        }
        String [] arr = splitCharToArray(str, delim);
        return Arrays.asList(arr);
    }

    /**
     * 修改字符串中小数保留位数
     * @param str 字符串
     * @param decimalDigitsNum 保留位数
     * @return
     */
    public static String decimalDigitsControl(String str, int decimalDigitsNum){
        try {
            if(isNumeric(str)){
                Integer num = str.indexOf(".");
                if (num < 0) return str;
                Integer number = str.length() - num - 1;
                if (number < decimalDigitsNum) return str;
                Double value = Double.valueOf(str);
                String key = "%." + decimalDigitsNum + "f";
                return subZeroAndDot(String.format(key, value));
            }
        }catch (Exception ex){
            ex.printStackTrace();
        }
        return str;

        //没进行四舍五入
		/*String result = str;
		if(isNumeric(str) && str.contains(".") && str.split("\\.")[1].length() > decimalDigitsNum){
			result = str.substring(0,str.indexOf(".") + decimalDigitsNum + 1);
		}
		return result;*/


    }

    /**
     * 可以替换大部分空白字符， 不限于空格 ；
     * \s 可以匹配空格、制表符、换页符等空白字符的其中任意一个
     * @param s
     * @return
     */
    public static String filterBlank(String s){
        return s.replaceAll("\\s*", "");
    }

    /**
     * 去除字符串首末单引号
     * @param s
     * @return
     */
    public static String getSubSingleQuotes(String s){
        if(isEmpty(s)){
            return "";
        }
        if(s.startsWith("'")){
            s = s.substring(1);
        }
        if(s.endsWith("'")){
            s = s.substring(0, s.length() - 1);
        }
        return s;
    }

    /**
     * 小括号包装字符串
     * @param s
     * @return
     */
    public static String parenthesesWrap(String s){
        if(isEmpty(s)){
            s = "("+s+")";
        }
        else{
            s = "";
        }
        return s;
    }

    /**
     * 將latex符号转为常用公式
     * @param str
     * @return
     */
    public static String getStrByLatex(String str){
        if(isEmpty(str)){
            return "";
        }
        // 替换 "或" 运算符
        str = str.replace("\\parallel", "||");

        //替换括号 \left(对应(
        str=str.replace("\\left", "");
        //替换括号  \right)对应)
        str=str.replace("\\right", "");
        if(str.indexOf("\\times")>0){//替换乘号 \times改为*
            str=str.replace("\\times ", "*");
            str=str.replace("\\times", "*");
        }
        if(str.indexOf("}{")>0){//替换除号 \frac{1}{2}对应 1/2
            str=str.replace("\\frac", "(");
            str=str.replace("}{", ")/(");
            str=str.replace("{", "");
            str=str.replace("}", ")");
        }
        if(str.indexOf("\\sqrt")>0){
            str=str.replace("\\sqrt", "sqrt");
        }
        if(str.indexOf("\\le")>0){
            str=str.replace("\\le", "≤");
        }
        if(str.indexOf("\\lt")>0){
            str=str.replace("\\lt", "<");
        }
        if(str.indexOf("\\ge")>0){
            str=str.replace("\\ge", "≥");
        }
        if(str.indexOf("\\gt")>0){
            str=str.replace("\\gt", ">");
        }
        return str;
    }

    /**
     * 拼接字符串
     * @param c 连接符
     * @param str 字符串
     * @return
     */
    public static String joinString(CharSequence c, String... str) {
        StringJoiner joiner = new StringJoiner(c);
        for (String s : str) {
            joiner.add(s);
        }
        return joiner.toString();
    }

    public static Boolean isCalString(String str) {
//		String regex = "(^\\d+)([\\+\\-\\*/]\\d+)+$";
//		return Pattern.matches(regex, str);
        return str.contains("+")
                || str.contains("*")
                || str.contains("/")
                || str.contains("-")
                || str.contains("<")
                || str.contains(">")
                || str.contains("=")
                || str.contains("≤")
                || str.contains("≥")
                || str.contains("min")
                || str.contains("max");
    }

    //汉字转换成二进制字符串
    public static String strToBinStr(String str) {
        char[] chars = str.toCharArray();
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < chars.length; i++) {
            result.append(Integer.toBinaryString(chars[i]));
            result.append(" ");
        }
        return result.toString();
    }
    /**把null转化为""*/
    public static String nulltoString(String str)
    {
        if (str == null)
            str = "";
        if (str.equals("null") || str.equals("NULL"))
            str = "";
        str = str.trim();
        return str;
    }

    /**
     * @return
     * @Title: removeLastSign
     * @Description: 移除字符串的最后一个字符
     * @author pangps
     * @param str
     * @throws
     */
    public static String removeLastSign(String str){
        if(str==null || "".equals(str)){
            return str;
        }
        else{
            return str.substring(0, str.length()-1);
        }
    }

    /**
     * 转义url字符
     * @param str
     * @return
     */
    public static String urlDecode(String str){
        if(str==null || "".equals(str)){
            return str;
        }
        else{
            try {
                return URLDecoder.decode(str, "utf-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
                return str;
            }
        }
    }

    public static Boolean isEmpty(Object obj) {
        return (obj == null || "".equals(obj));
    }

    public static Boolean isNotEmpty(Object obj) {
        return !isEmpty(obj);
    }

    public static void main(String[] args) {
        String str = "zhang";
        String str2 = "peng";
        String str3 = new String("zhangpeng");
        String str4 = "zhangpeng";
        str += str2;
        System.out.println(str == str3);
        System.out.println(str3 == str4);
    }
}
